home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / bin / autoscan-2.13 < prev    next >
Text File  |  2005-10-13  |  10KB  |  396 lines
  1. #! /usr/bin/perl
  2. # autoscan - Create configure.scan (a preliminary configure.in) for a package.
  3. # Copyright (C) 1994 Free Software Foundation, Inc.
  4.  
  5. # This program is free software; you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation; either version 2, or (at your option)
  8. # any later version.
  9.  
  10. # This program is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. # GNU General Public License for more details.
  14.  
  15. # You should have received a copy of the GNU General Public License
  16. # along with this program; if not, write to the Free Software
  17. # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18. # 02111-1307, USA.
  19.  
  20. # Written by David MacKenzie <djm@gnu.ai.mit.edu>.
  21.  
  22. require "find.pl";
  23.  
  24. $datadir = $ENV{"AC_MACRODIR"} || "/usr/share/autoconf";
  25. $verbose = 0;
  26. # Reference these variables to pacify perl -w.
  27. undef %identifiers_macros;
  28. undef %makevars_macros;
  29. undef %programs_macros;
  30.  
  31. &parse_args;
  32. &init_tables;
  33. &find('.');
  34. &scan_files;
  35. &output;
  36.  
  37. exit 0;
  38.  
  39. # Process any command line arguments.
  40. sub parse_args
  41. {
  42.     local ($usage) =
  43.     "Usage: autoscan [--macrodir=dir] [--help] [--verbose] [--version] [srcdir]\n"; 
  44.  
  45.     foreach $_ (@ARGV) {
  46.     if (/^--m[a-z]*=(.*)/) {
  47.         $datadir = $1;
  48.     } elsif (/^--h/) {
  49.         print "$usage";
  50.         exit 0;
  51.     } elsif (/^--verb/) {
  52.         $verbose = 1;
  53.     } elsif (/^--vers/) {
  54.         &version;
  55.     } elsif (/^[^-]/) {
  56.         die "$usage" if defined($srcdir);
  57.         # Top level directory of the package being autoscanned.
  58.         $srcdir = $_;
  59.     } else {
  60.         die "$usage";
  61.     }
  62.     }
  63.  
  64.     $srcdir="." if !defined($srcdir);
  65.  
  66.     print "srcdir=$srcdir\n" if $verbose;
  67.     chdir $srcdir || die "$0: cannot cd to $srcdir: $!\n";
  68.  
  69.     open(CONF, ">configure.scan") ||
  70.     die "$0: cannot create configure.scan: $!\n";
  71. }
  72.  
  73. # Print the version number and exit.
  74. sub version
  75. {
  76.     open(ACG, "<$datadir/acgeneral.m4") ||
  77.     die "$0: cannot open $datadir/acgeneral.m4: $!\n";
  78.     while (<ACG>) {
  79.     if (/define.AC_ACVERSION.\s*([0-9.]+)/) {
  80.         print "Autoconf version $1\n";
  81.         exit 0;
  82.     }
  83.     }
  84.     die "Autoconf version unknown\n";
  85. }
  86.  
  87. # Put values in the tables of what to do with each token.
  88. sub init_tables
  89. {
  90.     local($kind, $word, $macro);
  91.  
  92.     # Initialize a table of C keywords (to ignore).
  93.     # Taken from K&R 1st edition p. 180.
  94.     # ANSI C, GNU C, and C++ keywords can introduce portability problems,
  95.     # so don't ignore them.
  96.     foreach $word ('int', 'char', 'float', 'double', 'struct', 'union',
  97.            'long', 'short', 'unsigned', 'auto', 'extern', 'register',
  98.            'typedef', 'static', 'goto', 'return', 'sizeof', 'break',
  99.            'continue', 'if', 'else', 'for', 'do', 'while', 'switch',
  100.            'case', 'default') {
  101.     $c_keywords{$word} = 0;
  102.     }
  103.  
  104.     # The data file format supports only one line of macros per function.
  105.     # If more than that is required for a common portability problem,
  106.     # a new Autoconf macro should probably be written for that case,
  107.     # instead of duplicating the code in lots of configure.in files.
  108.  
  109.     foreach $kind ('functions', 'headers', 'identifiers', 'programs',
  110.            'makevars') {
  111.     open(TABLE, "<$datadir/ac$kind") ||
  112.         die "$0: cannot open $datadir/ac$kind: $!\n";
  113.     while (<TABLE>) {
  114.         next if /^\s*$/ || /^\s*#/; # Ignore blank lines and comments.
  115.         ($word, $macro) = split;
  116.         eval "\$$kind" . "_macros{\$word} = \$macro";
  117.     }
  118.     close(TABLE);
  119.     }
  120. }
  121.  
  122. # Collect names of various kinds of files in the package.
  123. # Called by &find on each file.
  124. sub wanted
  125. {
  126.     if (/^.*\.[chlymC]$/ || /^.*\.cc$/) {
  127.     $name =~ s?^\./??; push(@cfiles, $name);
  128.     }
  129.     elsif (/^[Mm]akefile$/ || /^[Mm]akefile\.in$/ || /^GNUmakefile$/) {
  130.     $name =~ s?^\./??; push(@makefiles, $name);
  131.     }
  132.     elsif (/^.*\.sh$/) {
  133.     $name =~ s?^\./??; push(@shfiles, $name);
  134.     }
  135. }
  136.  
  137. # Read through the files and collect lists of tokens in them
  138. # that might create nonportabilities.
  139. sub scan_files
  140. {
  141.     $initfile = $cfiles[0];        # Pick one at random.
  142.  
  143.     if ($verbose) {
  144.     print "cfiles:", join(" ", @cfiles), "\n";
  145.     print "makefiles:", join(" ", @makefiles), "\n";
  146.     print "shfiles:", join(" ", @shfiles), "\n";
  147.     }
  148.  
  149.     foreach $file (@cfiles) {
  150.     &scan_c_file($file);
  151.     }
  152.  
  153.     foreach $file (@makefiles) {
  154.     &scan_makefile($file);
  155.     }
  156.  
  157.     foreach $file (@shfiles) {
  158.     &scan_sh_file($file);
  159.     }
  160. }
  161.  
  162. sub scan_c_file
  163. {
  164.     local($file) = @_;
  165.     local($in_comment) = 0;    # Nonzero if in a multiline comment.
  166.  
  167.     open(CFILE, "<$file") || die "$0: cannot open $file: $!\n";
  168.     while (<CFILE>) {
  169.     # Strip out comments, approximately.
  170.     # Ending on this line.
  171.     if ($in_comment && m,\*/,) {
  172.         s,.*\*/,,;
  173.         $in_comment = 0;
  174.     }
  175.     # All on one line.
  176.     s,/\*.*\*/,,g;
  177.     # Starting on this line.
  178.     if (m,/\*,) {
  179.         $in_comment = 1;
  180.     }
  181.     # Continuing on this line.
  182.     next if $in_comment;
  183.  
  184.     # Preprocessor directives.
  185.     if (/^\s*#\s*include\s*<([^>]*)>/) {
  186.         $headers{$1}++;
  187.     }
  188.     # Ignore other preprocessor directives.
  189.     next if /^\s*#/;
  190.  
  191.     # Remove string and character constants.
  192.     s,\"[^\"]*\",,g;
  193.         s,\'[^\']*\',,g;
  194.  
  195.     # Tokens in the code.
  196.     # Maybe we should ignore function definitions (in column 0)?
  197.     while (s/\W([a-zA-Z_]\w*)\s*\(/ /) {
  198.         $functions{$1}++ if !defined($c_keywords{$1});
  199.     }
  200.     while (s/\W([a-zA-Z_]\w*)\W/ /) {
  201.         $identifiers{$1}++ if !defined($c_keywords{$1});
  202.     }
  203.     }
  204.     close(CFILE);
  205.  
  206.     if ($verbose) {
  207.     local($word);
  208.  
  209.     print "\n$file functions:\n";
  210.     foreach $word (sort keys %functions) {
  211.         print "$word $functions{$word}\n";
  212.     }
  213.  
  214.     print "\n$file identifiers:\n";
  215.     foreach $word (sort keys %identifiers) {
  216.         print "$word $identifiers{$word}\n";
  217.     }
  218.  
  219.     print "\n$file headers:\n";
  220.     foreach $word (sort keys %headers) {
  221.         print "$word $headers{$word}\n";
  222.     }
  223.     }
  224. }
  225.  
  226. sub scan_makefile
  227. {
  228.     local($file) = @_;
  229.  
  230.     open(MFILE, "<$file") || die "$0: cannot open $file: $!\n";
  231.     while (<MFILE>) {
  232.     # Strip out comments and variable references.
  233.     s/#.*//;
  234.     s/\$\([^\)]*\)//g;
  235.     s/\${[^\}]*}//g;
  236.     s/@[^@]*@//g;
  237.  
  238.     # Variable assignments.
  239.     while (s/\W([a-zA-Z_]\w*)\s*=/ /) {
  240.         $makevars{$1}++;
  241.     }
  242.     # Libraries.
  243.     while (s/\W-l([a-zA-Z_]\w*)\W/ /) {
  244.         $libraries{$1}++;
  245.     }
  246.     # Tokens in the code.
  247.     while (s/\W([a-zA-Z_]\w*)\W/ /) {
  248.         $programs{$1}++;
  249.     }
  250.     }
  251.     close(MFILE);
  252.  
  253.     if ($verbose) {
  254.     local($word);
  255.  
  256.     print "\n$file makevars:\n";
  257.     foreach $word (sort keys %makevars) {
  258.         print "$word $makevars{$word}\n";
  259.     }
  260.  
  261.     print "\n$file libraries:\n";
  262.     foreach $word (sort keys %libraries) {
  263.         print "$word $libraries{$word}\n";
  264.     }
  265.  
  266.     print "\n$file programs:\n";
  267.     foreach $word (sort keys %programs) {
  268.         print "$word $programs{$word}\n";
  269.     }
  270.     }
  271. }
  272.  
  273. sub scan_sh_file
  274. {
  275.     local($file) = @_;
  276.  
  277.     open(MFILE, "<$file") || die "$0: cannot open $file: $!\n";
  278.     while (<MFILE>) {
  279.     # Strip out comments and variable references.
  280.     s/#.*//;
  281.     s/\${[^\}]*}//g;
  282.     s/@[^@]*@//g;
  283.  
  284.     # Tokens in the code.
  285.     while (s/\W([a-zA-Z_]\w*)\W/ /) {
  286.         $programs{$1}++;
  287.     }
  288.     }
  289.     close(MFILE);
  290.  
  291.     if ($verbose) {
  292.     local($word);
  293.  
  294.     print "\n$file programs:\n";
  295.     foreach $word (sort keys %programs) {
  296.         print "$word $programs{$word}\n";
  297.     }
  298.     }
  299. }
  300.  
  301. # Print a configure.in.
  302. sub output
  303. {
  304.     local (%unique_makefiles);
  305.  
  306.     print CONF "dnl Process this file with autoconf to produce a configure script.\n";
  307.     print CONF "AC_INIT($initfile)\n";
  308.  
  309.     &output_programs;
  310.     &output_headers;
  311.     &output_identifiers;
  312.     &output_functions;
  313.  
  314.     # Change DIR/Makefile.in to DIR/Makefile.
  315.     foreach $_ (@makefiles) {
  316.     s/\.in$//;
  317.     $unique_makefiles{$_}++;
  318.     }
  319.     print CONF "\nAC_OUTPUT(", join(" ", keys(%unique_makefiles)), ")\n";
  320.  
  321.     close CONF;
  322. }
  323.  
  324. # Print Autoconf macro $1 if it's not undef and hasn't been printed already.
  325. sub print_unique
  326. {
  327.     local($macro) = @_;
  328.  
  329.     if (defined($macro) && !defined($printed{$macro})) {
  330.     print CONF "$macro\n";
  331.     $printed{$macro} = 1;
  332.     }
  333. }
  334.  
  335. sub output_programs
  336. {
  337.     local ($word);
  338.  
  339.     print CONF "\ndnl Checks for programs.\n";
  340.     foreach $word (sort keys %programs) {
  341.     &print_unique($programs_macros{$word});
  342.     }
  343.     foreach $word (sort keys %makevars) {
  344.     &print_unique($makevars_macros{$word});
  345.     }
  346.     print CONF "\ndnl Checks for libraries.\n";
  347.     foreach $word (sort keys %libraries) {
  348.     print CONF "dnl Replace `\main\' with a function in -l$word:\n";
  349.     print CONF "AC_CHECK_LIB($word, main)\n";
  350.     }
  351. }
  352.  
  353. sub output_headers
  354. {
  355.     local ($word);
  356.  
  357.     print CONF "\ndnl Checks for header files.\n";
  358.     foreach $word (sort keys %headers) {
  359.     if (defined($headers_macros{$word}) &&
  360.         $headers_macros{$word} eq 'AC_CHECK_HEADERS') {
  361.         push(@have_headers, $word);
  362.     } else {    
  363.         &print_unique($headers_macros{$word});
  364.     }
  365.     }
  366.     print CONF "AC_CHECK_HEADERS(" . join(' ', sort(@have_headers)) . ")\n"
  367.     if defined(@have_headers);
  368. }
  369.  
  370. sub output_identifiers
  371. {
  372.     local ($word);
  373.  
  374.     print CONF "\ndnl Checks for typedefs, structures, and compiler characteristics.\n";
  375.     foreach $word (sort keys %identifiers) {
  376.     &print_unique($identifiers_macros{$word});
  377.     }
  378. }
  379.  
  380. sub output_functions
  381. {
  382.     local ($word);
  383.  
  384.     print CONF "\ndnl Checks for library functions.\n";
  385.     foreach $word (sort keys %functions) {
  386.     if (defined($functions_macros{$word}) &&
  387.         $functions_macros{$word} eq 'AC_CHECK_FUNCS') {
  388.         push(@have_funcs, $word);
  389.     } else {    
  390.         &print_unique($functions_macros{$word});
  391.     }
  392.     }
  393.     print CONF "AC_CHECK_FUNCS(" . join(' ', sort(@have_funcs)) . ")\n"
  394.     if defined(@have_funcs);
  395. }
  396.